home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / djgpp / contrib / pdcurs22 / src / private / pdcdisp.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-26  |  43.3 KB  |  1,757 lines
  1. /*
  2. ***************************************************************************
  3. * This file comprises part of PDCurses. PDCurses is Public Domain software.
  4. * You may use this code for whatever purposes you desire. This software
  5. * is provided AS IS with NO WARRANTY whatsoever.
  6. * Should this software be used in another application, an acknowledgement
  7. * that PDCurses code is used would be appreciated, but is not mandatory.
  8. *
  9. * Any changes which you make to this software which may improve or enhance
  10. * it, should be forwarded to the current maintainer for the benefit of 
  11. * other users.
  12. *
  13. * The only restriction placed on this code is that no distribution of
  14. * modified PDCurses code be made under the PDCurses name, by anyone
  15. * other than the current maintainer.
  16. * 
  17. * See the file maintain.er for details of the current maintainer.
  18. ***************************************************************************
  19. */
  20. #include <string.h>
  21. #define    CURSES_LIBRARY    1
  22. #include <curses.h>
  23.  
  24. #ifndef NO_MEMORY_H
  25. #include <memory.h>
  26. #endif
  27.  
  28. #ifdef UNIX
  29. #include <defs.h>
  30. #include <term.h>
  31. #endif
  32.  
  33. #ifdef PDCDEBUG
  34. char *rcsid_PDCdisp  = "$Id$";
  35. #endif
  36.  
  37. /*man-start*********************************************************************
  38.  
  39.   PDC_backchar()    - Visually erase character in window
  40.  
  41.   PDCurses Description:
  42.      This is a private PDCurses function
  43.  
  44.      This routine will visually erase a character.  It is called by
  45.      the PDCurses character I/O routines.
  46.  
  47.   PDCurses Return Value:
  48.      This routine will return OK upon success and otherwise ERR will be
  49.      returned.
  50.  
  51.   PDCurses Errors:
  52.      It is an error to pass a NULL WINDOW pointer.
  53.  
  54.   Portability:
  55.      PDCurses    int    PDC_backchar( WINDOW* w, char* ch, int* len );
  56.  
  57. **man-end**********************************************************************/
  58.  
  59. #ifdef THESE_FUNCTIONS_ARENT_USED
  60. /***********************************************************************/
  61. int    PDC_backchar(WINDOW *w, char *ch, int *len)
  62. /***********************************************************************/
  63. {
  64.     int    nbs = 0;
  65.     int    x = w->_curx;
  66.     int    ts = w->_tabsize;
  67.     chtype    s = (w->_y[w->_cury][x - 1] & CHR_MSK);
  68.     char*    p = c_strbeg;
  69.     bool    save_raw_out = _cursvar.raw_out;
  70.  
  71. #ifdef PDCDEBUG
  72.     if (trace_on) PDC_debug("PDC_backchar() - called\n");
  73. #endif
  74.  
  75.     if (w == (WINDOW *)NULL)
  76.         return( ERR );
  77.  
  78.     (*len)--;        /* Now we are zero relative */
  79.     (*len)--;        /* Now we are looking at the previous
  80.                  * character */
  81.     if( *len >= 0 ) {
  82.         nbs++;
  83.         /*
  84.          * Determine number of characters to erase...
  85.          */
  86.         if ((ch[*len] < ' ') || (s == 0x7f))    /* ctrl-char has size 2     */
  87.         {
  88.             nbs++;
  89.             (*len)--;
  90.         }
  91.  
  92.         if( *len >= 0 )
  93.         if (ch[*len] == '\t')    /* tabs are very special */
  94.         {
  95.             for (; p < ch; p++)
  96.             {
  97.                 if (*p == '\t')
  98.                     x = ((x / ts) + 1) * ts;
  99.                 else
  100.                 {
  101.                     if ((*p < ' ') || (*p == 0x7f))
  102.                         x += 2;
  103.                     else
  104.                         x++;
  105.                 }
  106.                 if (x >= w->_maxx)    /* go to next line? */
  107.                     x = 0;
  108.             }
  109.             if (!(w->_curx))
  110.                 nbs = w->_maxx - x;
  111.             else
  112.                 nbs = w->_curx - x;
  113.         }
  114.     }
  115.     if( *len < 0 )
  116.     {
  117.         beep();
  118.         *len = 0;
  119.     }
  120.     /*
  121.      * Erase the characters and update...
  122.      */
  123.     _cursvar.raw_out = FALSE;  /* ensure backspace handled in xlat mode */
  124.     while ( nbs-- > 0 )
  125.     {
  126.         if (w->_curx > 0)
  127.         {
  128. /*            waddstr(w, "\b \b");*/
  129.             mvwaddch(w, w->_cury, w->_curx-1, ' ');
  130.             wmove(w, w->_cury, w->_curx-1);
  131.         }
  132.         else
  133.         if (w->_cury)
  134.         {
  135.             mvwaddch(w, w->_cury - 1, w->_maxx - 1, ' ');
  136.             wmove(w, w->_cury - 1, w->_maxx - 1);
  137.         }
  138.     }
  139.     ch[*len] = '\0';
  140.     _cursvar.raw_out = save_raw_out;
  141.     wrefresh(w);
  142.     return( OK );
  143. }
  144.  
  145. /*man-start*********************************************************************
  146.  
  147.   PDC_chg_attr_pair()    - Writes character and attribute to physical screen
  148.  
  149.   PDCurses Description:
  150.      This is a private PDCurses function.
  151.  
  152.      Writes a single character 'chr' with attribute 'attr' to the
  153.      current cursor location.
  154.  
  155.      NOTE:    Though passed as 16 bit quantities, only the lower 8 bits
  156.          will be used to create a character/attribute pair.
  157.  
  158.   PDCurses Return Value:
  159.      This function returns OK on success and ERR on error.
  160.  
  161.   PDCurses Errors:
  162.      No errors are defined for this function under DOS.
  163.  
  164.      An ERR may be returned under FLEXOS if s_copy() fails.  See the
  165.      Flexos Programmer's Reference Manual for details on the error.
  166.  
  167.   Portability:
  168.      PDCurses    int PDC_chg_attr_pair( chtype chr, chtype attr );
  169.  
  170. **man-end**********************************************************************/
  171.  
  172. /***********************************************************************/
  173. int    PDC_chg_attr_pair(chtype chr, chtype attr)
  174. /***********************************************************************/
  175. {
  176.     extern unsigned    char atrtab[MAX_ATRTAB];
  177.     int    phys_attr=chtype_attr(attr);
  178.  
  179. #ifdef    OS2
  180. # ifdef  EMXVIDEO
  181.     int curCol, curRow,cell;
  182. # else
  183.     USHORT curCol, curRow, cell;
  184. # endif
  185. #endif
  186.  
  187. #ifdef    FLEXOS
  188.     UBYTE    c = (UBYTE) chr;
  189.     UBYTE    a = (UBYTE) phys_attr;
  190. #endif
  191.  
  192. #ifdef PDCDEBUG
  193.     if (trace_on) PDC_debug("PDC_chg_attr_pair() - called\n");
  194. #endif
  195.  
  196. #ifdef    FLEXOS
  197.     drect.r_row = PDC_get_cur_row();
  198.     drect.r_col = PDC_get_cur_col();
  199.     drect.r_nrow = 1;
  200.     drect.r_ncol = 1;
  201.  
  202.     sframe.fr_pl[0] = (UBYTE *) & c;
  203.     sframe.fr_pl[1] = (UBYTE *) & a;
  204.     sframe.fr_pl[2] = (UBYTE *) " ";
  205.     sframe.fr_nrow = 1;
  206.     sframe.fr_ncol = 1;
  207.     sframe.fr_use = 0x00;
  208.  
  209.     srect.r_col = 0;
  210.     srect.r_row = 0;
  211.     srect.r_nrow = 1;
  212.     srect.r_ncol = 1;
  213.  
  214.     retcode = s_copy(0x03, 0x01L, 0L, (far unsigned short *) &drect, (far unsigned short *) &sframe, (far unsigned short *) &srect);
  215.     return( (retcode < 0L) ? ERR : OK );
  216. #endif
  217.  
  218. #ifdef    DOS
  219.     regs.h.ah = 0x09;
  220.     regs.h.al = chr & A_CHARTEXT;
  221.     regs.h.bh = _cursvar.video_page;
  222.     regs.h.bl = (char)(phys_attr >> 8);
  223. # ifdef WATCOMC
  224.     regs.w.cx = 0x01;
  225. # else
  226.     regs.x.cx = 0x01;
  227. # endif
  228.     int86(0x10, ®s, ®s);
  229.     return( OK );
  230. #endif
  231.  
  232. #ifdef    OS2
  233.     /* find the current cursor position */
  234. # ifdef EMXVIDEO
  235.     cell = (int)((chr & A_CHARTEXT) | phys_attr);
  236.     v_getxy (&curCol, &curRow);
  237.     v_putline ((char*)&cell, curCol, curRow, 1);
  238. # else
  239.     cell = (USHORT)((chr & A_CHARTEXT) | phys_attr);
  240.     VioGetCurPos((PUSHORT) &curRow, (PUSHORT) &curCol, 0);
  241.     VioWrtNCell((PBYTE)&cell,1,curRow,curCol,0);
  242. # endif
  243.     return( OK );
  244. #endif
  245.  
  246. #ifdef UNIX
  247. /* INCOMPLETE - check attribute and output attr and/or color */
  248.     putchar(chr & A_CHARTEXT);
  249.     return(OK);
  250. #endif
  251. }
  252. #endif
  253.  
  254. /*man-start*********************************************************************
  255.  
  256.   PDC_chadd()      - Low level; Put a character to a window
  257.  
  258.   PDCurses Description:
  259.         This is a private PDCurses function.
  260.  
  261.         This routine will insert the character 'c' at the current cursor
  262.         position in the passed window.
  263.  
  264.         If 'xlat' is TRUE, PDC_chadd() will handle things in a cooked
  265.         manner (tabs, newlines, carriage returns, etc).  If 'xlat' is
  266.         FALSE, the characters are simply output directly.
  267.  
  268.         If 'advance' is TRUE, PDC_chadd() will move the current cusor position
  269.         appropriately. The *addch functions call PDC_chadd() with advance TRUE,
  270.         while the *insch functions call PDC_chadd() with advance FALSE.
  271.  
  272.         The normal curses routines (non-raw-output-mode) call PDC_chadd()
  273.         with 'xlat' TRUE.
  274.  
  275.   PDCurses Return Value:
  276.         This function returns OK on success and ERR on error.
  277.  
  278.   PDCurses Errors:
  279.         It is an error to call this function with a NULL window pointer.
  280.  
  281.   Portability:
  282.         PDCurses        int PDC_chadd( WINDOW* win, chtype ch, bool xlat, bool advance );
  283.  
  284. **man-end**********************************************************************/
  285.  
  286. /***********************************************************************/
  287. int    PDC_chadd(register WINDOW *win, chtype ch,bool xlat, bool advance)
  288. /***********************************************************************/
  289. {
  290.     int    retval = ERR;
  291.     int    x=0;
  292.     int    y=0;
  293.     int    newx=0;
  294.     chtype    attr=0, bktmp=0;
  295.     int    ts=0;
  296.  
  297. #ifdef PDCDEBUG
  298.     if (trace_on) PDC_debug("PDC_chadd() - called: char=%c attr=0x%x xlat=%d advance=%d\n",ch & A_CHARTEXT,ch & A_ATTRIBUTES,xlat,advance);
  299. #endif
  300.  
  301.     if (win    == (WINDOW *)NULL)
  302.         return(    retval );
  303.  
  304.     x    = win->_curx;
  305.     y    = win->_cury;
  306.     ts    = win->_tabsize;
  307.  
  308. /* if the incoming character doesn't have its own attribute
  309.    then    use the    current    attributes for the window.
  310.    if the incoming character has attributes but    not a colour
  311.    component, or the attributes    to the current attributes
  312.    for the window.
  313.    if the incoming character has a colour component use    the
  314.    attributes solely from the incoming character */
  315.  
  316.     if ((ch    & A_ATTRIBUTES)    == 0)
  317.        attr    = win->_attrs;
  318.     else
  319.        if ((ch & A_COLOR) == 0)
  320.           attr = (ch & A_ATTRIBUTES) | win->_attrs;
  321.        else
  322.           attr = (ch & A_ATTRIBUTES);
  323.  
  324.     ch    = (ch &    A_CHARTEXT);
  325.  
  326. /*  wrs (4/10/93)
  327. /*  apply the same sort of logic for the window background, in that it only */
  328. /*  takes precedence if other color attributes are not there and that */
  329. /*  the background character will only print if the printing character is */
  330. /*  blank. */
  331.  
  332.     if ((attr & A_COLOR) == 0)
  333.        attr = (attr | (win->_bkgd & A_ATTRIBUTES));
  334.     else {
  335.        bktmp = (win->_bkgd & A_COLOR);
  336.        attr = (attr | ( (win->_bkgd & A_ATTRIBUTES) ^ bktmp ));
  337.     }
  338.  
  339.     if ( ch == ' ' )
  340.         ch = ((win->_bkgd & A_CHARTEXT));
  341.  
  342.  
  343.     if ((y > win->_maxy) ||
  344.         (x > win->_maxx) ||
  345.         (y < 0) ||
  346.         (x < 0))
  347.     {
  348.         return(    retval );
  349.     }
  350.  
  351.     if (xlat)
  352.     {
  353.         switch (ch) {
  354.         case '\t':
  355.             for (newx = ((x    / ts) +    1) * ts; x < newx; x++)
  356.             {
  357.                 if (waddch(win,    ' ') ==    ERR)
  358.                 {
  359.                     return(    retval );
  360.                 }
  361.                 /*
  362.                  * if tab to next line
  363.                  */
  364.                 if (win->_curx == 0)
  365.                 {
  366.                     /*
  367.                      * exit    the loop
  368.                      */
  369.                     return(    OK );
  370.                 }
  371.             }
  372.             return(    OK );
  373.  
  374.         case '\n':
  375.             if (_cursvar.autocr && !(_cursvar.raw_out))
  376.             {
  377.                 /*
  378.                  * if lf -> crlf
  379.                  */
  380.                 x = 0;
  381.             }
  382.             wclrtoeol( win );
  383.             if ((y = PDC_newline(win, y)) < 0)
  384.                 return(    retval );
  385.             if (advance)
  386.               {
  387.                win->_cury =    y;
  388.                win->_curx =    x;
  389.               }
  390.             return(    OK );
  391.  
  392.         case '\r':
  393.             if (advance)
  394.                win->_curx =    x = 0;
  395.             return(    OK );
  396.  
  397.         case '\b':
  398.             if (--x    < 0)
  399.             {
  400.                 /*
  401.                  * no back over    left margin
  402.                  */
  403.                 x = 0;
  404.             }
  405.             if (advance)
  406.                win->_curx =    x;
  407.             return(    OK );
  408.  
  409.         case 0x7f:
  410.             if (waddch(win,    '^') ==    ERR)
  411.             {
  412.                 return(    retval );
  413.             }
  414.             retval = waddch(win, '?');
  415.             return(    retval );
  416.  
  417.         default:
  418.             break;
  419.         }        /* switch */
  420.  
  421.         if (ch < ' ')
  422.         {
  423.             /*
  424.              * handle control chars
  425.              */
  426.             if (waddch(win,    '^') ==    ERR)
  427.                 return(    retval );
  428.  
  429.             retval = (waddch(win, ch + '@'));
  430.             return(    retval );
  431.         }
  432.     }
  433.  
  434.     /*
  435.      *    Add the    attribute back into the    character.
  436.      */
  437.     ch    |= attr;
  438. /*********************************************************************/
  439. /* only change _firstch/_lastch if character to be added is different */
  440. /* to the character/attribute that is already in that position in the */
  441. /* window.                                                            */
  442. /* Removing this fixes display problems with different windows in the */
  443. /* same physical position. MH 20-03-93                                */
  444. /* Restored again.         MH 02-04-93                                */
  445. /*********************************************************************/
  446.     if (win->_y[y][x] !=    ch)
  447.     {
  448.         /*
  449.          * only    if data    change
  450.          */
  451.         if (win->_firstch[y] ==    _NO_CHANGE)
  452.         {
  453.             win->_firstch[y] = win->_lastch[y] = x;
  454.         }
  455.         else
  456.         {
  457.             if (x <    win->_firstch[y])
  458.             {
  459.                 win->_firstch[y] = x;
  460.             }
  461.             else
  462.             {
  463.                 if (x >    win->_lastch[y])
  464.                 {
  465.                     win->_lastch[y] = x;
  466.                 }
  467.             }
  468.         }
  469.     }
  470.     win->_y[y][x++] = ch;
  471.     if (x >= win->_maxx)
  472.     {
  473.         /*
  474.          * wrap    around test
  475.          */
  476.         x = 0;
  477.         if ((y = PDC_newline(win, y)) < 0)
  478.             return(    retval );
  479.     }
  480.     if (advance)
  481.       {
  482.        win->_curx =    x;
  483.        win->_cury =    y;
  484.       }
  485.     return(    OK );
  486. }
  487.  
  488. /*man-start*********************************************************************
  489.  
  490.   PDC_chg_attrs()    - Change attributes in a rectangle
  491.  
  492.   PDCurses Description:
  493.      This routine will change the attribute(s) from a starting (y,x)
  494.      position to an ending (y,x) position to the specified attribute.
  495.  
  496.   PDCurses Return Value:
  497.      This function returns OK on success and ERR on error.
  498.  
  499.   PDCurses Errors:
  500.      It is an error to call this function with a NULL window pointer.
  501.      It is also an error to pass rectangular coordinates that lay
  502.      outside of window.
  503.  
  504.   Portability:
  505.      PDCurses    int PDC_chg_attrs( WINDOW* w, chtype attr,
  506.                      int sy, int sx,
  507.                      int ey, int ex );
  508.  
  509. **man-end**********************************************************************/
  510.  
  511. /***********************************************************************/
  512. int    PDC_chg_attrs(WINDOW *w, chtype attr, int sy, int sx, int ey, int ex)
  513. /***********************************************************************/
  514. {
  515.     chtype    oldattr = w->_attrs;
  516.     int    c=0;
  517.     int    l=0;
  518.  
  519. #ifdef PDCDEBUG
  520.     if (trace_on) PDC_debug("PDC_chr_attrs() - called\n");
  521. #endif
  522.  
  523.     if (w == (WINDOW *)NULL)        return( ERR );
  524.     if (sy > w->_maxy)    return( ERR );
  525.     if (sx > w->_maxx)    return( ERR );
  526.     if (ey >= w->_maxy)    ey = w->_maxy - 1;
  527.     if (ex >= w->_maxx)    ex = w->_maxx - 1;
  528.  
  529.     wattrset(w, attr);
  530.     for (l = sy; l <= ey; l++)
  531.     {
  532.         for (c = sx; c <= ex; c++)
  533.             w->_y[l][c] = (w->_y[l][c] & A_CHARTEXT) | attr;
  534.  
  535.         if (w->_firstch[l] == _NO_CHANGE)
  536.         {
  537.             w->_firstch[l] = sx;
  538.             w->_lastch[l] = ex;
  539.         }
  540.         else
  541.         if (w->_firstch[l] != _NO_CHANGE)
  542.         {
  543.             if (sx < w->_firstch[l])
  544.                 w->_firstch[l] = sx;
  545.             if (ex > w->_lastch[l])
  546.                 w->_lastch[l] = ex;
  547.         }
  548.     }
  549.     w->_attrs = oldattr;
  550.     return( OK );
  551. }
  552.  
  553. /*man-start*********************************************************************
  554.  
  555.   PDC_chins()    - Low-level insert character in window
  556.  
  557.   PDCurses Description:
  558.      This is a private PDCurses routine.
  559.  
  560.      This routine provides the basic functionality for the X/Open
  561.      [mv][w]insch() routines.  The xlat flag indicates that normal
  562.      character translation is performed or not.  If not, then the
  563.      character is output as is.
  564.  
  565.      The 'xlat' flag is TRUE for the normal curses routines.
  566.  
  567.   PDCurses Return Value:
  568.      This function returns OK on success and ERR on error.
  569.  
  570.   PDCurses Errors:
  571.      It is an error to call this function with a NULL window pointer.
  572.  
  573.   Portability:
  574.      PDCurses    int PDC_chins( WINDOW* win, chtype c, bool xlat );
  575.  
  576. **man-end**********************************************************************/
  577.  
  578. /***********************************************************************/
  579. int    PDC_chins(WINDOW *win, chtype c, bool xlat)
  580. /***********************************************************************/
  581. {
  582.     int    retval = ERR;
  583.     int    x=0;
  584.     int    y=0;
  585.     int    maxx=0;
  586.     int    offset=0;
  587.     chtype *temp1;
  588.     char    ch    = (c & A_CHARTEXT);
  589.  
  590. #ifdef PDCDEBUG
  591.     if (trace_on) PDC_debug("PDC_chins() - called\n");
  592. #endif
  593.  
  594.     if (win == (WINDOW *)NULL)
  595.         return( retval );
  596.  
  597.     x    = win->_curx;
  598.     y    = win->_cury;
  599.     maxx    = win->_maxx;
  600.     offset    = 1;
  601.     temp1    = &win->_y[y][x];
  602.  
  603.     if ((ch < ' ') && xlat)
  604.     {
  605.         offset++;
  606.     }
  607.  
  608.     memmove( temp1+offset, temp1, (maxx - x -offset) * sizeof(chtype) );
  609.  
  610.     win->_lastch[y] = maxx-1;
  611.  
  612.     if ((win->_firstch[y] == _NO_CHANGE) ||
  613.         (win->_firstch[y] > x))
  614.     {
  615.         win->_firstch[y] = x;
  616.     }
  617.     /*
  618.      * PDC_chadd() fixes CTRL-chars too
  619.      */
  620.     retval = (PDC_chadd(win, c, xlat,FALSE));
  621.     return( retval );
  622. }
  623.  
  624. /*man-start*********************************************************************
  625.  
  626.   PDC_clr_scrn()    - Clears the physical screen and homes the cursor.
  627.  
  628.   PDCurses Description:
  629.      This is an internal routine called by the doupdate() routines.
  630.  
  631.   PDCurses Return Value:
  632.      This routine always returns OK.
  633.  
  634.   Portability:
  635.      PDCurses    int PDC_clr_scrn( WINDOW* win );
  636.  
  637. **man-end**********************************************************************/
  638.  
  639. /***********************************************************************/
  640. int    PDC_clr_scrn(WINDOW *win)
  641. /***********************************************************************/
  642. {
  643. #if defined(UNIX_WCLR)
  644.     chtype    attrs = win->_attrs;
  645. #else
  646.     chtype    attrs = win->_bkgd;
  647. #endif
  648.  
  649. #ifdef PDCDEBUG
  650.     if (trace_on) PDC_debug("PDC_clr_scrn() - called\n");
  651. #endif
  652.  
  653. #if defined(XCURSES)
  654.     XCurses_instruct(CURSES_CLEAR);
  655. #else
  656.     PDC_scroll(0, 0, LINES - 1, COLS - 1, 0, attrs);
  657.     PDC_gotoxy(0, 0);
  658. #endif
  659.  
  660.     return( OK );
  661. }
  662. #ifndef NO_MEMORY_H
  663. #include <memory.h>
  664. #endif
  665.  
  666. /*man-start*********************************************************************
  667.  
  668.   PDC_clr_update()    - Updates the screen with a full redraw.
  669.  
  670.   PDCurses Description:
  671.      Updates the screen by clearing it and then redraw it in its
  672.      entirety. If _cursvar.refrbrk is TRUE, and there is pending
  673.      input characters, the update will be prematurely terminated.
  674.  
  675.   PDCurses Return Value:
  676.      This routine returns ERR if it is unable to accomplish it's task.
  677.      This return value is ONLY under FLEXOS.
  678.  
  679.      The return value OK is returned if there were no errors.
  680.  
  681.   PDCurses Errors:
  682.      No errors are defined for this function.
  683.  
  684.   Portability:
  685.      PDCurses    int PDC_clr_update( WINDOW* s );
  686.  
  687. **man-end**********************************************************************/
  688.  
  689. /***********************************************************************/
  690. int    PDC_clr_update(WINDOW *s)
  691. /***********************************************************************/
  692. {
  693. register int    i=0,j=0;
  694.     WINDOW*    w=NULL;
  695. #if defined(UNIX)
  696.     chtype*    ch;
  697. #else
  698.     unsigned short*    ch;
  699. #endif
  700.     bool rc=FALSE;
  701.  
  702. #if defined(DOS)
  703. #  if SMALL || MEDIUM
  704. struct SREGS segregs;
  705. int ds=0;
  706. #  endif
  707. #endif
  708.  
  709. #ifdef    FLEXOS
  710.     char    line[80];
  711.     char    attr[80];
  712.     FFRAME    sframe;
  713.     RECT    drect,
  714.         srect;
  715. #endif
  716. #if defined(DOS) && defined(NDP)
  717.     int *VIDPOINT;
  718. #endif
  719.  
  720.     extern unsigned    char atrtab[MAX_ATRTAB];
  721.  
  722. /* the next two varaibales have been changed from chtype to unsigned short */
  723. /* as this is the correct datatype for a physical character/attribute */
  724.     unsigned short temp_line[256]; /* this should be enough for the maximum width of a screen. MH-920715 */
  725.     unsigned short chr;
  726.  
  727. #ifdef PDCDEBUG
  728.     if (trace_on) PDC_debug("PDC_clr_update() - called\n");
  729. #endif
  730.  
  731.     w = curscr;
  732.     if (w == (WINDOW *)NULL)
  733.         return( ERR );
  734. /*    if (_cursvar.full_redraw)
  735.         PDC_clr_scrn(s); *//* clear physical screen */
  736.  
  737.     s->_clear = FALSE;
  738.     for (i = 0; i < LINES; i++)    /* update physical screen */
  739.     {
  740.         if (s != w)    /* copy s to curscr */
  741.  
  742.             memcpy(w->_y[i], s->_y[i], COLS * sizeof(chtype));
  743.  
  744.         ch = temp_line; /* now have ch pointing to area to contain real attributes. MH-920715 */
  745.  
  746.  
  747. #if defined(DOS) || defined(OS2)
  748. #  if 0
  749.         memcpy(ch,s->_y[i],COLS*sizeof(chtype)); /* copy current line to temp_line. MH-920715 */
  750.         for (j=0;j<COLS;j++)          /* for each chtype in the line... */
  751.            {
  752.             chr = temp_line[j] & A_CHARTEXT;
  753.             temp_line[j] = chtype_attr(temp_line[j]) | chr;
  754.            }
  755. #  else
  756.         for (j=0;j<COLS;j++)          /* for each chtype in the line... */
  757.            {
  758.             chr = (unsigned short)(s->_y[i][j] & A_CHARTEXT);
  759.             temp_line[j] = chtype_attr(s->_y[i][j]) | chr;
  760.            }
  761. #  endif
  762. #endif
  763.  
  764.         if (_cursvar.direct_video)
  765.         {
  766. #ifdef    FLEXOS
  767.             PDC_split_plane(w, &line[0], &attr[0], i, 0, i, COLS);
  768. /* need to translate attr[] array to real attributes before displaying it. MH-920715 */
  769.             drect.r_row = i;
  770.             drect.r_col = 0;
  771.             drect.r_nrow = 1;
  772.             drect.r_ncol = COLS;
  773.  
  774.             sframe.fr_pl[0] = (UBYTE *) line;
  775.             sframe.fr_pl[1] = (UBYTE *) attr;
  776.             sframe.fr_nrow = 1;
  777.             sframe.fr_ncol = COLS;
  778.             sframe.fr_use = 0x03;
  779.  
  780.             srect.r_col = 0;
  781.             srect.r_row = 0;
  782.             srect.r_nrow = 1;
  783.             srect.r_ncol = COLS;
  784.  
  785.             s_copy(0x03, 0x01L, 0L, (far unsigned short *) &drect,
  786.                 (far unsigned short *) &sframe,
  787.                 (far unsigned short *) &srect);
  788. #endif
  789.  
  790. #ifdef    DOS
  791. #  ifdef GO32
  792.             dosmemput (ch, COLS * sizeof(unsigned short),
  793.                 (void *)_FAR_POINTER(_cursvar.video_seg,
  794.                 _cursvar.video_ofs + (i * COLS * sizeof(unsigned short))));
  795. #  else
  796. #    if    (SMALL || MEDIUM)
  797.         segread(&segregs);
  798.         ds = segregs.ds;
  799.         movedata(ds, (int)ch,
  800.                 _cursvar.video_seg,
  801.                 _cursvar.video_ofs + (i*COLS*sizeof(unsigned short)),
  802.                     (COLS * sizeof(unsigned short)));
  803. #    else
  804. /*
  805. #    ifdef    NDP
  806.             VIDPOINT = (int *) mapdev(MK_FP(_cursvar.video_seg,
  807.               _cursvar.video_ofs + (i * COLS * sizeof(unsigned short))),
  808.               (COLS * sizeof(unsigned short)));
  809.             memcpy(VIDPOINT, (int *) ch, (COLS * sizeof(unsigned short)));
  810. */
  811.             memcpy((void *)_FAR_POINTER(_cursvar.video_seg,
  812.               _cursvar.video_ofs + (i * COLS * sizeof(unsigned short))),
  813.                    ch, (COLS * sizeof(unsigned short)));
  814. #    endif
  815. #  endif
  816. #endif
  817.  
  818. #ifdef    OS2
  819. # ifdef EMXVIDEO
  820.                 v_putline ((char *)ch, 0, i, COLS);
  821. # else
  822.                 VioWrtCellStr ((PCH)ch, (USHORT)(COLS * sizeof(unsigned short)), (USHORT)i, 0, 0);
  823. # endif
  824. #endif
  825.         }
  826.         else
  827.         {
  828.  
  829. #ifdef UNIX
  830.             PDC_gotoxy(i, 0);
  831.             for (j = 0; j < COLS; j++)
  832.             {
  833.                 PDC_putc( (*ch & A_CHARTEXT), (*ch & A_ATTRIBUTES) );
  834.                 ch++;
  835.             }
  836. #endif
  837.  
  838. #if defined(DOS) || defined(OS2)
  839.             for (j = 0; j < COLS; j++)
  840.             {
  841.                 PDC_gotoxy(i, j);
  842.                 PDC_putc( (*ch & A_CHARTEXT), (*ch & A_ATTRIBUTES) >> 8 );
  843.                 ch++;
  844.             }
  845. #endif
  846.  
  847. #if defined(XCURSES)
  848.         XCurses_transform_line(w->_y[i],i,0,COLS);
  849. #endif
  850.  
  851.         }
  852.  
  853.         if (_cursvar.refrbrk && (_cursvar.cbreak || _cursvar.raw_inp)) 
  854.         {
  855.             rc = PDC_breakout();
  856.             if(rc) 
  857.                 break;
  858.         }
  859.  
  860.     }
  861. #if defined(XCURSES)
  862.     XCurses_wait_for_display();
  863. #endif
  864.     return( OK );
  865. }
  866.  
  867. /*man-start*********************************************************************
  868.  
  869.   PDC_cursor_on()    - Turns on the hardware cursor.
  870.  
  871.   PDCurses Description:
  872.      Turns on the hardware curses, it does nothing if it is already on.
  873.  
  874.   PDCurses Return Value:
  875.      Returns OK upon success, ERR upon failure.
  876.  
  877.   Portability:
  878.      PDCurses    int PDC_cursor_on( void );
  879.  
  880. **man-end**********************************************************************/
  881.  
  882. /***********************************************************************/
  883. int    PDC_cursor_on(void)
  884. /***********************************************************************/
  885. {
  886. #ifdef PDCDEBUG
  887.     if (trace_on) PDC_debug("PDC_cursor_on() - called\n");
  888. #endif
  889.  
  890. #ifndef UNIX
  891.     if    (!_cursvar.visible_cursor)
  892.     {
  893.         _cursvar.visible_cursor = TRUE;
  894. /*        PDC_fix_cursor(_cursvar.orig_emulation);*/
  895.         if (_cursvar.bogus_adapter)
  896.         {
  897.             PDC_set_cursor_mode((_cursvar.cursor & 0xff00) >> 8,
  898.                      (_cursvar.cursor & 0x00ff));
  899.         }
  900.         else
  901.         {
  902. #ifdef     OS2
  903.             PDC_set_cursor_mode((_cursvar.cursor & 0xff00) >> 8,
  904.                          (_cursvar.cursor & 0x00ff));
  905. #else
  906.             switch (_cursvar.adapter) {
  907.             case _MDA:
  908.             case _CGA:
  909.             case _EGACOLOR:
  910.             case _EGAMONO:
  911.             case _VGACOLOR:
  912.             case _VGAMONO:
  913.             case _MDS_GENIUS:
  914. /*                PDC_set_cursor_mode(_cursvar.font - 2, _cursvar.font - 1);*/
  915.                 PDC_set_cursor_mode((_cursvar.cursor & 0xff00) >> 8,
  916.                          (_cursvar.cursor & 0x00ff));
  917.                 break;
  918.             case _MCGACOLOR:
  919.             case _MCGAMONO:
  920. /*                PDC_set_cursor_mode(_cursvar.font - 1, _cursvar.font - 2);*/
  921.                 PDC_set_cursor_mode((_cursvar.cursor & 0xff00) >> 8,
  922.                          (_cursvar.cursor & 0x00ff));
  923.                 break;
  924.             case _FLEXOS:
  925.                 PDC_set_cursor_mode(_cursvar.visible_cursor, 0);
  926.                 break;
  927.             default:
  928.                 break;
  929.             }
  930. #endif
  931.         }
  932.     }
  933. #endif
  934.     return( OK );
  935. }
  936.  
  937. /*man-start*********************************************************************
  938.  
  939.   PDC_cursor_off()    - Turns off the hardware cursor.
  940.  
  941.   PDCurses Description:
  942.      Turns off the hardware curses, it does nothing if it is already off.
  943.  
  944.   PDCurses Return Value:
  945.      Returns OK upon success, ERR upon failure.
  946.  
  947.   PDCurses Errors:
  948.      ERR will be returned (in the case of FLEXOS) if the hardware cursor
  949.      can not be disabled.
  950.  
  951.   Portability:
  952.      PDCurses    int PDC_cursor_off( void );
  953.  
  954. **man-end**********************************************************************/
  955.  
  956. /***********************************************************************/
  957. int    PDC_cursor_off(void)
  958. /***********************************************************************/
  959. {
  960. #ifdef PDCDEBUG
  961.     if (trace_on) PDC_debug("PDC_cursor_off() - called\n");
  962. #endif
  963.  
  964. #ifndef UNIX
  965.     if    (_cursvar.visible_cursor)
  966.     {
  967.         _cursvar.visible_cursor = FALSE;
  968. #ifdef     OS2
  969.         PDC_set_cursor_mode(32, 33);    /* turn it off */
  970. #else
  971.         switch (_cursvar.adapter)
  972.         {
  973.         case _FLEXOS:
  974.             PDC_set_cursor_mode(_cursvar.visible_cursor, 0);
  975.             break;
  976.         default:
  977.             PDC_set_cursor_mode(32, 33);    /* turn it off */
  978.             break;
  979.         }
  980. #endif
  981.     }
  982. #endif
  983.     return( OK );
  984. }
  985.  
  986. /*man-start*********************************************************************
  987.  
  988.   PDC_fix_cursor()    - Fix the cursor start and stop scan lines (if necessary)
  989.  
  990.   PDCurses Description:
  991.      This is a private PDCurses routine.
  992.  
  993.      This routine will fix the cursor shape for certain video adapters.
  994.      Normally, the values used are correct, but some adapters choke.
  995.      The most noticable choke is on a monochrome adapter.  The "correct"
  996.      scan lines will result in the cursor being set in the middle of the
  997.      character cell, rather than at the bottom.
  998.  
  999.      The passed flag indicates whether the cursor is visible or not.
  1000.  
  1001.      This only applies to the DOS platform.
  1002.  
  1003.   PDCurses Return Value:
  1004.      This function returns OK on success and ERR on error.
  1005.  
  1006.   PDCurses Errors:
  1007.      No errors are defined for this function.
  1008.  
  1009.   Portability:
  1010.      PDCurses    int PDC_fix_cursor( int flag );
  1011.  
  1012. **man-end**********************************************************************/
  1013.  
  1014. /***********************************************************************/
  1015. int    PDC_fix_cursor(int flag)
  1016. /***********************************************************************/
  1017. {
  1018. #ifdef    DOS
  1019.  
  1020. #ifdef PDCDEBUG
  1021.     if (trace_on) PDC_debug("PDC_fix_cursor() - called\n");
  1022. #endif
  1023.  
  1024. #ifdef    FLEXOS
  1025.     return( OK );
  1026. #endif
  1027.  
  1028.     if (_cursvar.bogus_adapter)
  1029.         return( OK );
  1030.  
  1031.     switch (_cursvar.adapter)
  1032.     {
  1033.     case _EGACOLOR:
  1034.     case _EGAMONO:
  1035.     case _MDS_GENIUS:        /* Some clones look like a Genius;-)  */
  1036.         if (flag & 0x01)
  1037.             setdosmembyte (0x487, getdosmembyte (0x487) | 0x01); /* Enable emulation */
  1038.         else
  1039.             setdosmembyte (0x487, getdosmembyte (0x487) & ~0x01); /* Disable emulation */
  1040.         break;
  1041.  
  1042.     case _VGACOLOR:
  1043.     case _VGAMONO:
  1044.         if (flag & 0x01)
  1045. #ifdef WATCOMC
  1046.             regs.w.ax = 0x1200;        /* Enable  emulation */
  1047. #else
  1048.             regs.x.ax = 0x1200;        /* Enable  emulation */
  1049. #endif
  1050.         else
  1051. #ifdef WATCOMC
  1052.             regs.w.ax = 0x1201;        /* Disable emulation */
  1053. #else
  1054.             regs.x.ax = 0x1201;        /* Disable emulation */
  1055. #endif
  1056.         regs.h.bl = 0x34;
  1057.         int86(0x10, ®s, ®s);
  1058.  
  1059.         break;
  1060.  
  1061.     case _MCGACOLOR:
  1062.     case _MCGAMONO:
  1063.     case _MDA:
  1064.     case _CGA:
  1065.     case _NONE:
  1066.     default:
  1067.         break;
  1068.     }
  1069.     return( OK );
  1070. #endif
  1071.  
  1072. #ifdef     OS2
  1073.         return( OK );
  1074. #endif
  1075.  
  1076. #ifdef     UNIX
  1077.         return( OK );
  1078. #endif
  1079. }
  1080. #ifdef UNIX
  1081. #include <defs.h>
  1082. #include <term.h>
  1083. #endif
  1084.  
  1085. /*man-start*********************************************************************
  1086.  
  1087.   PDC_gotoxy()    - position hardware cursor at (x, y)
  1088.  
  1089.   PDCurses Description:
  1090.      This is a private PDCurses routine.
  1091.  
  1092.      Moves the physical cursor to the desired address on the
  1093.      screen. We don't optimize here -- on a PC, it takes more time
  1094.      to optimize than to do things directly.
  1095.  
  1096.   PDCurses Return Value:
  1097.      This function returns OK on success and ERR on error.
  1098.  
  1099.   PDCurses Errors:
  1100.      No errors are defined for this function.
  1101.  
  1102.   Portability:
  1103.      PDCurses    int PDC_gotoxy( int row, int col );
  1104.  
  1105. **man-end**********************************************************************/
  1106.  
  1107. /***********************************************************************/
  1108. int    PDC_gotoxy(int row, int col)
  1109. /***********************************************************************/
  1110. {
  1111. #ifdef PDCDEBUG
  1112.     if (trace_on) PDC_debug("PDC_gotoxy() - called: row %d col %d\n",row,col);
  1113. #endif
  1114.  
  1115. #ifndef UNIX
  1116.     if ((_cursvar.cursrow == row) && (_cursvar.curscol == col))
  1117.         return( OK );
  1118. #endif
  1119.  
  1120. #ifdef    FLEXOS
  1121.     retcode = s_get(T_VIRCON, 0L, (char *) &vir, (long) sizeof(vir));
  1122.     if (retcode < 0L)
  1123.         return( ERR );
  1124.     vir.vc_cursor.pos_row = row;
  1125.     vir.vc_cursor.pos_col = col;
  1126.     retcode = s_set(T_VIRCON, 0L, (char *) &vir, (long) sizeof(vir));
  1127.     return( (retcode < 0L) ? ERR : OK );
  1128. #endif
  1129.  
  1130. #ifdef    DOS
  1131.     regs.h.ah = 0x02;
  1132.     regs.h.bh = _cursvar.video_page;
  1133.     regs.h.dh = (unsigned char) row;
  1134.     regs.h.dl = (unsigned char) col;
  1135.     int86(0x10, ®s, ®s);
  1136.     return( OK );
  1137. #endif
  1138.  
  1139. #ifdef    OS2
  1140. # ifdef EMXVIDEO
  1141.     v_gotoxy (col, row);
  1142. # else
  1143.     VioSetCurPos (row, col, 0);
  1144. # endif
  1145.     return(OK);
  1146. #endif
  1147.  
  1148. #ifdef UNIX
  1149.     if (cursor_address != NULL)
  1150.         {
  1151.         putp(tparm(cursor_address,row,col));
  1152.         }
  1153.     return(OK);
  1154. #endif
  1155.  
  1156. #if defined (XCURSES)
  1157.     XCurses_display_cursor(_cursvar.cursrow,_cursvar.curscol,
  1158.         curscr->_y[_cursvar.cursrow][_cursvar.curscol],
  1159.         row,col,curscr->_y[row][col]);
  1160.     return(OK);
  1161. #endif
  1162. }
  1163.  
  1164. /*man-start*********************************************************************
  1165.  
  1166.   PDC_newline()    - Advances 1 newline from supplied line number.
  1167.  
  1168.   PDCurses Description:
  1169.      This is a private PDCurses routine.
  1170.  
  1171.      Does line advance and returns the new cursor line.  If error,
  1172.      return -1.
  1173.  
  1174.   PDCurses Return Value:
  1175.      This function returns OK on success and ERR on error.
  1176.  
  1177.   PDCurses Errors:
  1178.      No errors are defined for this function.
  1179.  
  1180.   Portability:
  1181.      PDCurses    int PDC_newline( WINDOW* win, int lin );
  1182.  
  1183. **man-end**********************************************************************/
  1184.  
  1185. /***********************************************************************/
  1186. int    PDC_newline(WINDOW *win, int lin)
  1187. /***********************************************************************/
  1188. {
  1189. #ifdef PDCDEBUG
  1190.     if (trace_on) PDC_debug("PDC_newline() - called: line %d\n",lin);
  1191. #endif
  1192.  
  1193.     if (win == (WINDOW *)NULL)
  1194.         return( -1 );
  1195.  
  1196.     if (++lin > win->_bmarg)
  1197.     {
  1198.         lin--;
  1199.         if (win->_scroll)
  1200.         {
  1201.             scroll(win);
  1202.  
  1203. /* wrs -- 7/11/93 ** it seems that System V Curses automatically refreshes
  1204.  *                   a window when scrolling occurs via a newline.  This
  1205.  *                   could be a feature that isn't intended, but I'll
  1206.  *                   implement it here as well for consistency.
  1207.  */
  1208.              wrefresh(win);
  1209.         }
  1210.         else
  1211.             return( -1 );
  1212.     }
  1213.     return( lin );
  1214. }
  1215.  
  1216. /*man-start*********************************************************************
  1217.  
  1218.   PDC_putc()    - Output a character in the current attribute.
  1219.  
  1220.   PDCurses Description:
  1221.      This is a private PDCurses routine.
  1222.  
  1223.      Outputs character 'chr' to screen in tty fashion. If a colour
  1224.      mode is active, the character is written with colour 'colour'.
  1225.  
  1226.   PDCurses Return Value:
  1227.      This function returns OK on success and ERR on error.
  1228.  
  1229.   PDCurses Errors:
  1230.      No errors are defined for this function.
  1231.  
  1232.   Portability:
  1233.      PDCurses    int PDC_putc( chtype character, chtype color );
  1234.  
  1235. **man-end**********************************************************************/
  1236.  
  1237. /***********************************************************************/
  1238. int    PDC_putc( chtype character, chtype color )
  1239. /***********************************************************************/
  1240. {
  1241. #ifdef    OS2
  1242.     int curRow=0, curCol=0;
  1243. # ifdef EMXVIDEO
  1244.     char Cell[2];
  1245. # endif
  1246. #endif
  1247.  
  1248. #ifdef UNIX
  1249. static chtype last_attribute=0;
  1250. #  ifdef CHTYPE_LONG
  1251. static bool last_acs=FALSE;
  1252. #  endif
  1253. static int curses_to_ansi[] = {0,4,2,6,1,5,3,7};
  1254. short fore=0,back=0;
  1255. #endif
  1256.  
  1257. #ifdef PDCDEBUG
  1258.     if (trace_on) PDC_debug("PDC_putc() - called:char=%c attrib=0x%x color=0x%x\n",character & A_CHARTEXT,character & A_ATTRIBUTES,color);
  1259. #endif
  1260.  
  1261. #ifdef    FLEXOS
  1262.     retcode = s_write(0x00, 0x01L, (_far char *) &character, 1L, 0);
  1263.     return( (retcode < 0L) ? ERR : OK );
  1264. #endif
  1265.  
  1266. #ifdef    DOS
  1267.     regs.h.ah = 0x09;    /* Avoid screen wrap.  Don't advance cursor. */
  1268.     regs.h.al = (unsigned char) (character & A_CHARTEXT);
  1269.     regs.h.bh = _cursvar.video_page;
  1270.     regs.h.bl = (unsigned char) (color);
  1271. #ifdef WATCOMC
  1272.     regs.w.cx = 1;
  1273. #else
  1274.     regs.x.cx = 1;
  1275. #endif
  1276.     int86(0x10, ®s, ®s);
  1277.     return( OK );
  1278. #endif
  1279.  
  1280. #ifdef    OS2
  1281.     PDC_get_cursor_pos (&curRow, &curCol);
  1282. # ifdef EMXVIDEO
  1283.     Cell[0] = (char)character;
  1284.     Cell[1] = (char)color;
  1285.     v_putline (Cell, curCol, curRow, 1);
  1286. # else
  1287.     VioWrtTTY ((PCH)&character, 1, 0);
  1288.     VioWrtNAttr ((PBYTE)&color, 1, (USHORT)curRow, (USHORT)curCol, 0);
  1289.     PDC_gotoxy (curRow, curCol);
  1290. # endif
  1291.     return( OK );
  1292. #endif
  1293.  
  1294. #ifdef UNIX
  1295.     if (last_attribute != color)
  1296.         {
  1297.         if (exit_attribute_mode != NULL)
  1298.             putp(exit_attribute_mode);
  1299.         last_attribute = color;
  1300.         if ((color & A_COLOR) && has_colors())
  1301.             {
  1302.             pair_content(PAIR_NUMBER(color),&fore,&back);
  1303.             putp(tparm(set_foreground,curses_to_ansi[fore]));
  1304.             putp(tparm(set_background,curses_to_ansi[back]));
  1305.             }
  1306.         if (color & A_BOLD)
  1307.             if (enter_bold_mode != NULL)
  1308.                 putp(enter_bold_mode);
  1309.         if (color & A_BLINK)
  1310.             if (enter_blink_mode != NULL)
  1311.                 putp(enter_blink_mode);
  1312.         if (color & A_REVERSE)
  1313.             if (enter_reverse_mode != NULL)
  1314.                 putp(enter_reverse_mode);
  1315. #ifdef CHTYPE_LONG
  1316.         if (color & A_STANDOUT)
  1317.             if (enter_standout_mode != NULL)
  1318.                 putp(enter_standout_mode);
  1319.         if (color & A_ALTCHARSET)
  1320.             {
  1321.             if (last_acs == FALSE)
  1322.                 if (enter_alt_charset_mode != NULL)
  1323.                     putp(enter_alt_charset_mode);
  1324.             last_acs = TRUE;
  1325.             }
  1326.         else
  1327.             {
  1328.             last_acs = FALSE;
  1329.             if (exit_alt_charset_mode != NULL)
  1330.                 putp(exit_alt_charset_mode);
  1331.             }
  1332. #endif
  1333.         }
  1334.     putchar(character & A_CHARTEXT);
  1335.     return( OK );
  1336. #endif
  1337. }
  1338.  
  1339. /*man-start*********************************************************************
  1340.  
  1341.   PDC_putctty()    - Output a character and attribute in TTY fashion.
  1342.  
  1343.   PDCurses Description:
  1344.      This is a private PDCurses routine.
  1345.  
  1346.      Outputs character 'chr' to screen in tty fashion. If a colour
  1347.      mode is active, the character is written with colour 'colour'.
  1348.  
  1349.      This function moves the physical cursor after writing so the
  1350.      screen will scroll if necessary.
  1351.  
  1352.   PDCurses Return Value:
  1353.      This function returns OK on success and ERR on error.
  1354.  
  1355.   PDCurses Errors:
  1356.      No errors are defined for this function.
  1357.  
  1358.   Portability:
  1359.      PDCurses    int PDC_putctty( chtype character, chtype color );
  1360.  
  1361. **man-end**********************************************************************/
  1362.  
  1363. /***********************************************************************/
  1364. int    PDC_putctty( chtype character, chtype color )
  1365. /***********************************************************************/
  1366. {
  1367. #ifdef    OS2
  1368.     int curRow=0, curCol=0;
  1369. #endif
  1370.  
  1371. #ifdef PDCDEBUG
  1372.     if (trace_on) PDC_debug("PDC_putctty() - called\n");
  1373. #endif
  1374.  
  1375. #ifdef    FLEXOS
  1376.     retcode = s_write(0x00, 0x01L, (_far char *) &character, 1L, 0);
  1377.     return( (retcode < 0L) ? ERR : OK );
  1378. #endif
  1379.  
  1380. #ifdef    DOS
  1381.     regs.h.ah = 0x0e;    /* Write in TTY fashion, advance cursor. */
  1382.     regs.h.al = (unsigned char) (character & A_CHARTEXT);
  1383.     regs.h.bh = _cursvar.video_page;
  1384.     regs.h.bl = (unsigned char) ((color & A_ATTRIBUTES) >> 8);
  1385.     int86(0x10, ®s, ®s);
  1386.     return( OK );
  1387. #endif
  1388.  
  1389. #ifdef    OS2
  1390.     PDC_get_cursor_pos (&curRow, &curCol);
  1391. # ifdef EMXVIDEO
  1392.     v_attrib (color);
  1393.     v_putc (character);
  1394. # else
  1395.     VioWrtTTY ((PCH)&character, 1, 0);
  1396.     VioWrtNAttr ((PBYTE)&color, 1, (USHORT)curRow, (USHORT)curCol, 0);
  1397. # endif
  1398.     return( OK );
  1399. #endif
  1400.  
  1401. #ifdef UNIX
  1402. /* INCOMPLETE */
  1403.     return( OK );
  1404. #endif
  1405. }
  1406.  
  1407. /*man-start*********************************************************************
  1408.  
  1409.   PDC_scroll()    - low level screen scroll
  1410.  
  1411.   PDCurses Description:
  1412.      Scrolls a window in the current page up or down. Urow, lcol,
  1413.      lrow, rcol are the window coordinates.    Lines is the number of
  1414.      lines to scroll. If 0, clears the window, if < 0 scrolls down,
  1415.      if > 0 scrolls up.  Blanks areas that are left, and sets
  1416.      character attributes to attr. If in a colour graphics mode,
  1417.      fills them with the colour 'attr' instead.
  1418.  
  1419.   PDCurses Return Value:
  1420.      The PDC_scroll() function returns OK on success otherwise ERR is returned.
  1421.  
  1422.   PDCurses Errors:
  1423.      An error will only be returned on the Flexos platform if s_copy()
  1424.      fails.
  1425.  
  1426.   Portability:
  1427.      PDCurses    int PDC_scroll( int urow, int lcol, int rcol,
  1428.                       int nlines, chtype attr );
  1429.  
  1430. **man-end**********************************************************************/
  1431.  
  1432. /***********************************************************************/
  1433. int    PDC_scroll(int urow, int lcol, int lrow, int rcol, int nlines, chtype attr)
  1434. /***********************************************************************/
  1435. {
  1436.     extern unsigned    char atrtab[MAX_ATRTAB];
  1437.     int    phys_attr=chtype_attr(attr);
  1438. #ifdef    FLEXOS
  1439.     int    srow=0;
  1440.     int    scol=0;
  1441.     int    drow=0;
  1442.     int    dcol=0;
  1443.     int    nrows=0;
  1444.     int    ncols=0;
  1445.     char    blank = (char) _cursvar.blank;
  1446. #endif
  1447.  
  1448. #ifdef    OS2
  1449. # ifndef EMXVIDEO
  1450.     USHORT ch=(phys_attr | _cursvar.blank);
  1451. # endif
  1452. #endif
  1453.  
  1454. #ifdef PDCDEBUG
  1455.     if (trace_on) PDC_debug("PDC_scroll() - called: urow %d lcol %d lrow %d rcol %d nlines %d\n",urow,lcol,lrow,rcol,nlines);
  1456. #endif
  1457.  
  1458. #ifdef    FLEXOS
  1459.     if (nlines == 0)
  1460.     {
  1461.         sframe.fr_pl[0] = (UBYTE *) & blank;
  1462.         sframe.fr_pl[1] = (UBYTE *) & attr;
  1463.         sframe.fr_pl[2] = (UBYTE *) " ";
  1464.         sframe.fr_nrow = 1;
  1465.         sframe.fr_ncol = 1;
  1466.         sframe.fr_use = 0x00;
  1467.         nrows = lrow;
  1468.         ncols = rcol;
  1469.         srow = drow = 0;
  1470.         scol = dcol = 0;
  1471.     }
  1472.     else
  1473.     if (nlines < 0)
  1474.     {
  1475.         srow = urow;
  1476.         scol = lcol;
  1477.         drow = lrow;
  1478.         dcol = rcol;
  1479.     }
  1480.     else
  1481.     if (nlines > 0)
  1482.     {
  1483.         srow = urow;
  1484.         scol = lcol;
  1485.         drow = lrow;
  1486.         dcol = lcol;
  1487.     }
  1488.  
  1489.     drect.r_row = drow;
  1490.     drect.r_col = dcol;
  1491.     drect.r_nrow = nrows;
  1492.     drect.r_ncol = ncols;
  1493.  
  1494.     srect.r_col = scol;
  1495.     srect.r_row = srow;
  1496.     srect.r_nrow = nrows;
  1497.     srect.r_ncol = ncols;
  1498.  
  1499.     if (nlines != 0)
  1500.         retcode = s_copy(0x03, 0x01L, 0L, (far unsigned short *) &drect, 0L, (far unsigned short *) &srect);
  1501.     else
  1502.         retcode = s_copy(0x03, 0x01L, 0L, (far unsigned short *) &drect, (far unsigned short *) &sframe, (far unsigned short *) &srect);
  1503.     return( (retcode < 0L) ? ERR : OK );
  1504. #endif
  1505.  
  1506. #ifdef    DOS
  1507.     if (nlines >= 0)
  1508.     {
  1509.         regs.h.ah = 0x06;
  1510.         regs.h.al = (unsigned char) nlines;
  1511.     }
  1512.     else
  1513.     {
  1514.         regs.h.ah = 0x07;
  1515.         regs.h.al = (unsigned char) (-nlines);
  1516.     }
  1517.     regs.h.bh = (unsigned char)(phys_attr >> 8);
  1518.     regs.h.ch = (unsigned char) urow;
  1519.     regs.h.cl = (unsigned char) lcol;
  1520.     regs.h.dh = (unsigned char) lrow;
  1521.     regs.h.dl = (unsigned char) rcol;
  1522.     int86(0x10, ®s, ®s);
  1523.     return( OK );
  1524. #endif
  1525.  
  1526. #ifdef    OS2
  1527. # ifdef EMXVIDEO
  1528.     v_attrib (phys_attr);
  1529.     if (nlines > 0)
  1530.         v_scroll (lcol, urow, rcol, lrow, nlines, V_SCROLL_UP);
  1531.     else
  1532.         if (nlines < 0)
  1533.             v_scroll (lcol, urow, rcol, lrow, -nlines, V_SCROLL_DOWN);
  1534.         else    /* this clears the whole screen */
  1535.             v_scroll (lcol, urow, rcol, lrow, -1, V_SCROLL_CLEAR);
  1536. # else
  1537.     if (nlines > 0)
  1538.         VioScrollUp(urow, lcol, lrow, rcol, nlines, (PBYTE)&ch, 0);
  1539.     else
  1540.         if (nlines < 0)
  1541.             VioScrollDn(urow, lcol, lrow, rcol, nlines, (PBYTE)&ch, 0);
  1542.         else
  1543. /* this clears the whole screen ?? */
  1544.             VioScrollUp(0, 0, -1, -1, -1, (PBYTE)&ch, 0);
  1545. # endif
  1546. #endif
  1547.  
  1548. #ifdef UNIX
  1549. /* INCOMPLETE */
  1550. #endif
  1551. }
  1552.  
  1553. /*man-start*********************************************************************
  1554.  
  1555.   PDC_transform_line()    - display a physical line of the screen
  1556.  
  1557.   PDCurses Description:
  1558.      This is a private PDCurses function.
  1559.  
  1560.      Updates the given physical line to look like the corresponding
  1561.      line in _curscr.
  1562.  
  1563.   PDCurses Return Value:
  1564.      This routine returns TRUE if a premature refresh end
  1565.      is allowed, and there is an input character pending.  Otherwise,
  1566.      FALSE is returned.
  1567.  
  1568.   PDCurses Errors:
  1569.      No errors are defined for this routine.
  1570.  
  1571.   Portability:
  1572.      PDCurses    bool    PDC_transform_line( int lineno );
  1573.  
  1574. **man-end**********************************************************************/
  1575.  
  1576. /***********************************************************************/
  1577. bool    PDC_transform_line(register int lineno)
  1578. /***********************************************************************/
  1579. {
  1580. #if defined (MSC) && defined (DOS)
  1581. chtype*    dstp=NULL;
  1582. chtype*    srcp=NULL;
  1583. #else
  1584. register chtype*    dstp=NULL;
  1585. register chtype*    srcp=NULL;
  1586. #endif
  1587.  
  1588. #ifdef DOS
  1589. #if SMALL || MEDIUM
  1590. struct SREGS segregs;
  1591. int ds=0;
  1592. #endif
  1593. #endif
  1594.  
  1595.     int    x=0;
  1596.     int    endx=0;
  1597.     int    len=0;
  1598. #if defined(DOS) && defined(NDP)
  1599.     int *VIDPOINT;
  1600. #endif
  1601.     extern unsigned    char atrtab[MAX_ATRTAB];
  1602.  
  1603. #if defined(DOS) || defined(OS2)
  1604.     unsigned short temp_line[256]={0}; /* this should be enough for the maximum width of a screen. MH-920715 */
  1605.     unsigned short chr=0;
  1606.     unsigned short*    ch=NULL;
  1607. #else
  1608.     chtype temp_line[256]={0}; /* this should be enough for the maximum width of a screen. MH-920715 */
  1609.     chtype chr=0;
  1610.     chtype*    ch=NULL;
  1611. #endif
  1612.  
  1613.     register int j=0;
  1614.     bool rc=FALSE;
  1615.  
  1616. #ifdef    FLEXOS
  1617.     char    line[80];
  1618.     char    attr[80];
  1619.     FFRAME    sframe;
  1620.     RECT    drect;
  1621.     RECT    srect;
  1622. #endif
  1623.  
  1624. #ifdef PDCDEBUG
  1625.     if (trace_on) PDC_debug("PDC_transform_line() - called\n");
  1626. #endif
  1627.  
  1628.     if (curscr == (WINDOW *)NULL)
  1629.         return( FALSE );
  1630.  
  1631.     x = curscr->_firstch[lineno];
  1632.     endx = curscr->_lastch[lineno];
  1633.     dstp = curscr->_y[lineno] + x;
  1634.     srcp = curscr->_y[lineno] + x;
  1635.     len = endx-x+1;
  1636.  
  1637.     ch = temp_line; /* now have ch pointing to area to contain real attributes. MH-920715 */
  1638.  
  1639. /* replace the attribute part of the chtype with the actual colour value */
  1640. /* replacing the number that points to the actual colour value.          */
  1641.  
  1642. #if defined(DOS) || defined(OS2)
  1643. #  if 0
  1644.         memcpy(ch, srcp, len * sizeof(chtype));
  1645.     for (j=0;j<len;j++)          /* for each chtype in the line... */
  1646.        {
  1647.         chr = temp_line[j] & A_CHARTEXT;
  1648.         temp_line[j] = chtype_attr(temp_line[j]) | chr;
  1649.        }
  1650. #  else
  1651.     for (j=0;j<len;j++)          /* for each chtype in the line... */
  1652.        {
  1653.         chr = *(srcp+j) & A_CHARTEXT;
  1654.         temp_line[j] = chtype_attr(*(srcp+j)) | chr;
  1655.        }
  1656. #  endif
  1657. #endif
  1658.  
  1659.     if (_cursvar.direct_video)
  1660.     {
  1661.  
  1662. #if IS_THIS_REALLY_NEEDED
  1663.         memcpy(dstp, srcp, len * sizeof(chtype));
  1664. #endif
  1665.  
  1666. #ifdef    FLEXOS
  1667.         _split_plane(curscr, &line[0], &attr[0], lineno, x, lineno, endx);
  1668.  
  1669.         drect.r_row = lineno;
  1670.         drect.r_col = x;
  1671.         drect.r_nrow = 1;
  1672.         drect.r_ncol = len;
  1673.  
  1674.         sframe.fr_pl[0] = (UBYTE *) line;
  1675.         sframe.fr_pl[1] = (UBYTE *) attr;
  1676.         sframe.fr_nrow = 1;
  1677.         sframe.fr_ncol = len;
  1678.         sframe.fr_use = 0x03;
  1679.  
  1680.         srect.r_col = 0;
  1681.         srect.r_row = 0;
  1682.         srect.r_nrow = 1;
  1683.         srect.r_ncol = len;
  1684.  
  1685.         s_copy(0x03, 0x01L, 0L, (far unsigned short *) &drect,
  1686.             (far unsigned short *) &sframe, (far unsigned
  1687.             short *) &srect);
  1688.  
  1689. #endif
  1690.  
  1691. #ifdef    DOS
  1692. #  ifdef GO32
  1693.         dosmemput (ch, len * sizeof(unsigned short),
  1694.             (void *)_FAR_POINTER(_cursvar.video_seg,
  1695.             _cursvar.video_ofs + (((lineno * curscr->_maxx) + x) * sizeof(unsigned short))));
  1696. #  else
  1697. #    if    SMALL || MEDIUM
  1698.         segread(&segregs);
  1699.         ds = segregs.ds;
  1700.         movedata(ds,(int)ch,
  1701.             _cursvar.video_seg,
  1702.             _cursvar.video_ofs+(((lineno*curscr->_maxx)+x)*sizeof(unsigned short)),
  1703.                 len * sizeof(unsigned short));
  1704. #    else
  1705.         memcpy((void *)_FAR_POINTER(_cursvar.video_seg,
  1706.                  _cursvar.video_ofs + (((lineno * curscr->_maxx) + x) * sizeof(unsigned short))),
  1707.                ch, len * sizeof(unsigned short));
  1708. #    endif
  1709. #  endif
  1710. #endif
  1711.  
  1712. #ifdef    OS2
  1713. # ifdef EMXVIDEO
  1714.                     v_putline ((char*)ch, x, lineno, len);
  1715. # else
  1716.                     VioWrtCellStr ((PCH)ch, (USHORT)(len*sizeof(unsigned short)), (USHORT)lineno, (USHORT)x, 0);
  1717. # endif
  1718. #endif
  1719.     }
  1720.     else
  1721.     {
  1722.  
  1723. #ifdef UNIX
  1724.         PDC_gotoxy(lineno,x);
  1725.         for (; x <= endx; x++)
  1726.         {
  1727.             PDC_putc( (*ch & A_CHARTEXT),(*ch & A_ATTRIBUTES) );
  1728.             ch++;
  1729.         }
  1730. #endif
  1731.  
  1732. #if defined(DOS) || defined(OS2)
  1733.         for (; x <= endx; x++)
  1734.         {
  1735.             PDC_gotoxy(lineno, x);
  1736.             PDC_putc( (*ch & A_CHARTEXT),(*ch & A_ATTRIBUTES) >> 8 );
  1737.             ch++;
  1738.         }
  1739. #endif
  1740.  
  1741. #if defined(XCURSES)
  1742.         XCurses_transform_line(dstp,lineno,x,len);
  1743. #endif
  1744.  
  1745.     }
  1746.     curscr->_firstch[lineno] = _NO_CHANGE;
  1747.     curscr->_lastch[lineno] = _NO_CHANGE;
  1748.  
  1749.     if (_cursvar.refrbrk && (_cursvar.cbreak || _cursvar.raw_inp)) 
  1750.     {
  1751.         rc = PDC_breakout();
  1752.         if(rc) 
  1753.             return(TRUE);
  1754.     }
  1755.     return(FALSE);
  1756. }
  1757.